// assignment operator with lists
//#include <iostream>
//#include <list>
//
//int main()
//{
//	std::list<int> first(3);      // list of 3 zero-initialized ints
//	std::list<int> second(5);     // list of 5 zero-initialized ints
//
//	second = first;
//	first = std::list<int>();
//
//	std::cout << "Size of first: " << int(first.size()) << '\n';
//	std::cout << "Size of second: " << int(second.size()) << '\n';
//	return 0;
//}

//#include<iostream>
//#include<list>
//using namespace std;
//
//int main()
//{
//	list<int> lt({ 1,2,3,4 });
//	
//	list<int>::iterator it = lt.begin();
//	while (it != lt.end()) {
//		cout << *it << " ";
//		++it;
//	}
//	cout << endl;
//
//	list<int>::reverse_iterator rit = lt.rbegin();
//	while (rit != lt.rend()) {
//		cout << *rit << " ";
//		++rit;
//	}
//	cout << endl;
//
//	return 0;
//}


//#include<iostream>
//#include<list>
//using namespace std;
//
//int main()
//{
//	list<int> lt1;
//	list<int> lt2({ 1,2,3,4 });
//
//	cout << "lt1.empty():" << lt1.empty() << endl;
//	cout << "lt2.empty():" << lt2.empty() << endl;
//	cout << endl;
//
//	cout << "lt1.size():" << lt1.size() << endl;
//	cout << "lt2.size():" << lt2.size() << endl;
//
//	return 0;
//}

//#include<iostream>
//#include<list>
//using namespace std;
//
//int main()
//{
//	list<int> lt({ 1,2,3,4 });
//
//	cout << lt.front() << endl;
//	cout << lt.back() << endl;
//
//	return 0;
//}

//#include<iostream>
//#include<list>
//using namespace std;
//
//int main()
//{
//	list<int> lt1({ 1,2,3,4 });
//	list<int> lt2({ 0,0,0,0 });
//
//	lt1.assign(lt2.begin(), lt2.end());
//	for (auto e : lt1) {
//		cout << e << " ";
//	}
//	cout << endl;
//
//	lt1.assign(8, -1);
//	for (auto e : lt1) {
//		cout << e << " ";
//	}
//
//	return 0;
//}

//#include<iostream>
//#include<list>
//using namespace std;
//
//int main()
//{
//	list<int> lt({ 0,0,0 });
//
//	for (auto e : lt) {cout << e << " ";}
//	cout << endl;
//
//	lt.push_back(-1);
//	for (auto e : lt) { cout << e << " "; }
//	cout << endl;
//
//	lt.pop_back();
//	for (auto e : lt) { cout << e << " "; }
//	cout << endl;
//
//	lt.push_front(-1);
//	for (auto e : lt) { cout << e << " "; }
//	cout << endl;
//
//	lt.pop_front();
//	for (auto e : lt) { cout << e << " "; }
//	cout << endl;
//
//	return 0;
//}

//// inserting into a list
//#include <iostream>
//#include <list>
//#include <vector>
//
//int main()
//{
//    std::list<int> mylist;
//    std::list<int>::iterator it;
//
//    // set some initial values:
//    for (int i = 1; i <= 5; ++i) mylist.push_back(i); // 1 2 3 4 5
//
//    it = mylist.begin();
//    ++it;       // it points now to number 2           ^
//
//    mylist.insert(it, 10);                        // 1 10 2 3 4 5
//
//    // "it" still points to number 2                      ^
//    mylist.insert(it, 2, 20);                      // 1 10 20 20 2 3 4 5
//
//    --it;       // it points now to the second 20            ^
//
//    std::vector<int> myvector(2, 30);
//    mylist.insert(it, myvector.begin(), myvector.end());
//    // 1 10 20 30 30 20 2 3 4 5
//    //               ^
//    std::cout << "mylist contains:";
//    for (it = mylist.begin(); it != mylist.end(); ++it)
//        std::cout << ' ' << *it;
//    std::cout << '\n';
//
//    return 0;
//}


//#include<iostream>
//#include<list>
//using namespace std;
//
//int main()
//{
//	list<int> lt({ 1,2,3,4,5 });
//	for (auto e : lt) { cout << e << " "; }
//	cout << endl;
//
//	list<int>::iterator it = lt.begin();
//	++it;
//	it = lt.erase(it);
//	for (auto e : lt) { cout << e << " "; }
//	cout << endl;
//
//	it = lt.erase(it, lt.end());
//	for (auto e : lt) { cout << e << " "; }
//	cout << endl;
//
//	return 0;
//}

//// resizing list
//#include <iostream>
//#include <list>
//
//int main()
//{
//    std::list<int> mylist;
//
//    // set some initial content:
//    for (int i = 1; i < 10; ++i) mylist.push_back(i);
//
//    mylist.resize(5);
//    mylist.resize(8, 100);
//    mylist.resize(12);
//
//    std::cout << "mylist contains:";
//    for (std::list<int>::iterator it = mylist.begin(); it != mylist.end(); ++it)
//        std::cout << ' ' << *it;
//
//    std::cout << '\n';
//
//    return 0;
//}

//// splicing lists
//#include <iostream>
//#include <list>
//
//int main()
//{
//    std::list<int> mylist1, mylist2;
//    std::list<int>::iterator it;
//
//    // set some initial values:
//    for (int i = 1; i <= 4; ++i)
//        mylist1.push_back(i);      // mylist1: 1 2 3 4
//
//    for (int i = 1; i <= 3; ++i)
//        mylist2.push_back(i * 10);   // mylist2: 10 20 30
//
//    it = mylist1.begin();
//    ++it;                         // points to 2
//
//    mylist1.splice(it, mylist2); // mylist1: 1 10 20 30 2 3 4
//    // mylist2 (empty)
//    // "it" still points to 2 (the 5th element)
//
//    mylist2.splice(mylist2.begin(), mylist1, it);
//    // mylist1: 1 10 20 30 3 4
//    // mylist2: 2
//    // "it" is now invalid.
//    it = mylist1.begin();
//    std::advance(it, 3);           // "it" points now to 30
//
//    mylist1.splice(mylist1.begin(), mylist1, it, mylist1.end());
//    // mylist1: 30 3 4 1 10 20
//
//    std::cout << "mylist1 contains:";
//    for (it = mylist1.begin(); it != mylist1.end(); ++it)
//        std::cout << ' ' << *it;
//    std::cout << '\n';
//
//    std::cout << "mylist2 contains:";
//    for (it = mylist2.begin(); it != mylist2.end(); ++it)
//        std::cout << ' ' << *it;
//    std::cout << '\n';
//
//    return 0;
//}

//// remove from list
//#include <iostream>
//#include <list>
//
//int main()
//{
//    int myints[] = { 17,89,7,14 };
//    std::list<int> mylist(myints, myints + 4);
//
//    mylist.remove(89);
//
//    std::cout << "mylist contains:";
//    for (std::list<int>::iterator it = mylist.begin(); it != mylist.end(); ++it)
//        std::cout << ' ' << *it;
//    std::cout << '\n';
//
//    return 0;
//}

//// list::remove_if
//#include <iostream>
//#include <list>
//
//// a predicate implemented as a function:
//bool single_digit(const int& value) { return (value < 10); }
//
//// a predicate implemented as a class:
//struct is_odd {
//    bool operator() (const int& value) { return (value % 2) == 1; }
//};
//
//int main()
//{
//    int myints[] = { 15,36,7,17,20,39,4,1 };
//    std::list<int> mylist(myints, myints + 8);   // 15 36 7 17 20 39 4 1
//
//    mylist.remove_if(single_digit);           // 15 36 17 20 39
//
//    mylist.remove_if(is_odd());               // 36 20
//
//    std::cout << "mylist contains:";
//    for (std::list<int>::iterator it = mylist.begin(); it != mylist.end(); ++it)
//        std::cout << ' ' << *it;
//    std::cout << '\n';
//
//    return 0;
//}


//// list::unique
//#include <iostream>
//#include <cmath>
//#include <list>
//
//// a binary predicate implemented as a function:
//bool same_integral_part(double first, double second)
//{
//    return (int(first) == int(second));
//}
//
//// a binary predicate implemented as a class:
//struct is_near {
//    bool operator() (double first, double second)
//    {
//        return (fabs(first - second) < 5.0);
//    }
//};
//
//int main()
//{
//    double mydoubles[] = { 12.15,  2.72, 73.0,  12.77,  3.14,
//                         12.77, 73.35, 72.25, 15.3,  72.25 };
//    std::list<double> mylist(mydoubles, mydoubles + 10);
//
//    mylist.sort();             //  2.72,  3.14, 12.15, 12.77, 12.77,
//    // 15.3,  72.25, 72.25, 73.0,  73.35
//
//    mylist.unique();           //  2.72,  3.14, 12.15, 12.77
//    // 15.3,  72.25, 73.0,  73.35
//
//    mylist.unique(same_integral_part);  //  2.72,  3.14, 12.15
//    // 15.3,  72.25, 73.0
//
//    mylist.unique(is_near());           //  2.72, 12.15, 72.25
//
//    std::cout << "mylist contains:";
//    for (std::list<double>::iterator it = mylist.begin(); it != mylist.end(); ++it)
//        std::cout << ' ' << *it;
//    std::cout << '\n';
//
//    return 0;
//}


//// list::merge
//#include <iostream>
//#include <list>
//
//// compare only integral part:
//bool mycomparison(double first, double second)
//{
//    return (int(first) < int(second));
//}
//
//int main()
//{
//    std::list<double> first, second;
//
//    first.push_back(3.1);
//    first.push_back(2.2);
//    first.push_back(2.9);
//
//    second.push_back(3.7);
//    second.push_back(7.1);
//    second.push_back(1.4);
//
//    first.sort();
//    second.sort();
//
//    first.merge(second);
//
//    // (second is now empty)
//
//    second.push_back(2.1);
//
//    first.merge(second, mycomparison);
//
//    std::cout << "first contains:";
//    for (std::list<double>::iterator it = first.begin(); it != first.end(); ++it)
//        std::cout << ' ' << *it;
//    std::cout << '\n';
//
//    return 0;
//}


//#include<iostream>
//#include<list>
//
//class great
//{
//public:
//	bool operator()(int x, int y)
//	{
//		return x > y;
//	}
//};
//
//int main()
//{
//	std::list<int> lt({ 9,3,4,7,1 });
//	for (auto e : lt)std::cout << e << " ";
//	std::cout << std::endl;
//
//	lt.sort();
//	for (auto e : lt)std::cout << e << " ";
//	std::cout << std::endl;
//
//	lt.sort(great());
//	for (auto e : lt)std::cout << e << " ";
//	std::cout << std::endl;
//
//
//	return 0;
//}



#include<iostream>
#include<list>

int main()
{
	std::list<int> lt({ 9,3,4,7,1 });
	for (auto e : lt)std::cout << e << " ";
	std::cout << std::endl;

	lt.reverse();
	for (auto e : lt)std::cout << e << " ";
	std::cout << std::endl;

	return 0;
}